home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / DJINC106.ARJ / FIX24.H < prev    next >
C/C++ Source or Header  |  1992-03-29  |  12KB  |  586 lines
  1. // This may look like C code, but it is really -*- C++ -*-
  2. /* 
  3. Copyright (C) 1988 Free Software Foundation
  4.     written by Kurt Baudendistel (gt-eedsp!baud@gatech.edu)
  5.     adapted for libg++ by Doug Lea (dl@rocky.oswego.edu)
  6.  
  7. This file is part of the GNU C++ Library.  This library is free
  8. software; you can redistribute it and/or modify it under the terms of
  9. the GNU Library General Public License as published by the Free
  10. Software Foundation; either version 2 of the License, or (at your
  11. option) any later version.  This library is distributed in the hope
  12. that it will be useful, but WITHOUT ANY WARRANTY; without even the
  13. implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14. PURPOSE.  See the GNU Library General Public License for more details.
  15. You should have received a copy of the GNU Library General Public
  16. License along with this library; if not, write to the Free Software
  17. Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  19.  
  20. #ifndef _Fix24_h
  21. #ifdef __GNUG__
  22. #pragma interface
  23. #endif
  24. #define _Fix24_h 1
  25.  
  26. #include <stream.h>
  27. #include <std.h>
  28.  
  29. // extra type definitions 
  30.  
  31. typedef struct {
  32.   long                 u;
  33.   unsigned long           l;
  34. } twolongs;
  35.  
  36. // constant definitions
  37.  
  38. static const int
  39.   Fix24_shift = 31;
  40.           
  41. static const double
  42.   Fix24_fs = 2147483648.,        // 2^Fix24_shift
  43.   Fix24_mult = Fix24_fs,
  44.   Fix24_div = 1./Fix24_fs,
  45.   Fix24_max = 1. - .5/Fix24_fs,
  46.   Fix24_min = -1.;
  47.       
  48. static const unsigned long
  49.   Fix24_msb = 0x80000000L,
  50.   Fix24_lsb = 0x00000100L,
  51.   Fix24_m_max = 0x7fffff00L,
  52.   Fix24_m_min = 0x80000000L;
  53.  
  54. static const double
  55.   Fix48_fs = 36028797018963968.,    // 2^(24+Fix24_shift)
  56.   Fix48_max = 1. - .5/Fix48_fs,
  57.   Fix48_min = -1.,
  58.   Fix48_div_u = 1./Fix24_fs,
  59.   Fix48_div_l = 1./Fix48_fs;
  60.    
  61. static const twolongs
  62.   Fix48_msb = { 0x80000000L, 0L },
  63.   Fix48_lsb = { 0L, 0x00000100L },
  64.   Fix48_m_max = { 0x7fffff00L, 0xffffff00L },
  65.   Fix48_m_min = { 0x80000000L, 0L };
  66.           
  67. //
  68. // Fix24    class: 24-bit Fixed point data type
  69. //
  70. //    consists of a 24-bit mantissa (sign bit & 23 data bits).
  71. //
  72.  
  73. class Fix24 
  74. { 
  75.   friend class          Fix48;
  76.  
  77.   long                  m;
  78.  
  79.   long                  assign(double d);
  80.          operator       double();
  81.                         Fix24(long i);
  82.                         Fix24(int i);
  83.  
  84.  
  85. public:
  86.                         Fix24();
  87.                         Fix24(Fix24&  f);
  88.                         Fix24(double d);
  89.                         Fix24(Fix48& f);
  90.  
  91.                         ~Fix24();
  92.  
  93.   Fix24&                operator=(Fix24&  f);
  94.   Fix24&                operator=(double d);
  95.   Fix24&                operator=(Fix48& f);
  96.  
  97.   friend long&          mantissa(Fix24&  f);
  98.   friend double         value(Fix24&  f);
  99.  
  100.   Fix24                 operator +  ();
  101.   Fix24                 operator -  ();
  102.  
  103.   friend Fix24          operator +  (Fix24&  f, Fix24&  g);
  104.   friend Fix24          operator -  (Fix24&  f, Fix24&  g);
  105.   friend Fix48          operator *  (Fix24&  f, Fix24&  g);
  106.   friend Fix24          operator *  (Fix24&  f, int     g);
  107.   friend Fix24          operator *  (int     g, Fix24&  f);
  108.   friend Fix24          operator /  (Fix24&  f, Fix24&  g);
  109.   friend Fix24          operator << (Fix24&  f, int b);
  110.   friend Fix24          operator >> (Fix24&  f, int b);
  111.  
  112.   Fix24&                operator += (Fix24&  f);
  113.   Fix24&                operator -= (Fix24&  f);
  114.   Fix24&                operator *= (Fix24&  f);
  115.   Fix24&                operator *= (int     b);
  116.   Fix24&                operator /= (Fix24&  f);
  117.  
  118.   Fix24&                operator <<=(int b);
  119.   Fix24&                operator >>=(int b);
  120.  
  121.   friend int            operator == (Fix24&  f, Fix24&  g);
  122.   friend int            operator != (Fix24&  f, Fix24&  g);
  123.   friend int            operator >= (Fix24&  f, Fix24&  g);
  124.   friend int            operator <= (Fix24&  f, Fix24&  g);
  125.   friend int            operator >  (Fix24&  f, Fix24&  g);
  126.   friend int            operator <  (Fix24&  f, Fix24&  g);
  127.  
  128.   friend istream&       operator >> (istream& s, Fix24&  f);
  129.   friend ostream&       operator << (ostream& s, Fix24&  f);
  130.  
  131.   void                  overflow(long&);
  132.   void                  range_error(long&);
  133. };
  134.  
  135.  
  136. //
  137. // Fix48 class: 48-bit Fixed point data type
  138. //
  139. //    consists of a 48-bit mantissa (sign bit & 47 data bits).
  140. //
  141.  
  142. class Fix48 
  143. { 
  144.   friend class         Fix24;
  145.  
  146.   twolongs             m;
  147.  
  148.   twolongs             assign(double d);
  149.          operator      double();
  150.                        Fix48(twolongs i);
  151.  
  152. public:
  153.                        Fix48();
  154.                        Fix48(Fix48& f);
  155.                        Fix48(Fix24&  f);
  156.                        Fix48(double d);
  157.                        ~Fix48();
  158.  
  159.   Fix48&               operator =  (Fix48& f);
  160.   Fix48&               operator =  (Fix24&  f);
  161.   Fix48&               operator =  (double d);
  162.  
  163.   friend twolongs&     mantissa(Fix48& f);
  164.   friend double        value(Fix48& f);
  165.  
  166.   Fix48                operator +  ();
  167.   Fix48                operator -  ();
  168.  
  169.   friend Fix48         operator +  (Fix48& f, Fix48& g);
  170.   friend Fix48         operator -  (Fix48& f, Fix48& g);
  171.   friend Fix48         operator *  (Fix48& f, int    g);
  172.   friend Fix48         operator *  (int    g, Fix48& f);
  173.   friend Fix48         operator << (Fix48& f, int b);
  174.   friend Fix48         operator >> (Fix48& f, int b);
  175.  
  176.   friend Fix48         operator *  (Fix24&  f, Fix24&  g);
  177.  
  178.   Fix48&               operator += (Fix48& f);
  179.   Fix48&               operator -= (Fix48& f);
  180.   Fix48&               operator *= (int    b);
  181.   Fix48&               operator <<=(int b);
  182.   Fix48&               operator >>=(int b);
  183.  
  184.   friend int           operator == (Fix48& f, Fix48& g);
  185.   friend int           operator != (Fix48& f, Fix48& g);
  186.   friend int           operator >= (Fix48& f, Fix48& g);
  187.   friend int           operator <= (Fix48& f, Fix48& g);
  188.   friend int           operator >  (Fix48& f, Fix48& g);
  189.   friend int           operator <  (Fix48& f, Fix48& g);
  190.  
  191.   friend istream&      operator >> (istream& s, Fix48& f);
  192.   friend ostream&      operator << (ostream& s, Fix48& f);
  193.  
  194.   void                 overflow(twolongs& i);
  195.   void                 range_error(twolongs& i);
  196. };
  197.  
  198.  
  199. // active error handler declarations
  200.  
  201. typedef void (*Fix24_peh)(long&);
  202. typedef void (*Fix48_peh)(twolongs&);
  203.  
  204. extern Fix24_peh Fix24_overflow_handler;
  205. extern Fix48_peh Fix48_overflow_handler;
  206.  
  207. extern Fix24_peh Fix24_range_error_handler;
  208. extern Fix48_peh Fix48_range_error_handler;
  209.  
  210.  
  211. // error handler declarations
  212.  
  213. #if defined(SHORT_NAMES) || defined(VMS)
  214. #define    set_overflow_handler    sohndl
  215. #define set_range_error_handler    srnghdl
  216. #endif
  217.  
  218. extern Fix24_peh set_Fix24_overflow_handler(Fix24_peh);
  219. extern Fix48_peh set_Fix48_overflow_handler(Fix48_peh);
  220. extern void set_overflow_handler(Fix24_peh, Fix48_peh);
  221.  
  222. extern Fix24_peh set_Fix24_range_error_handler(Fix24_peh);
  223. extern Fix48_peh set_Fix48_range_error_handler(Fix48_peh);
  224. extern void set_range_error_handler(Fix24_peh, Fix48_peh);
  225.  
  226. extern void
  227.   Fix24_ignore(long&),
  228.   Fix24_overflow_saturate(long&),
  229.   Fix24_overflow_warning_saturate(long&),
  230.   Fix24_warning(long&),
  231.   Fix24_abort(long&);
  232.  
  233. extern void
  234.   Fix48_ignore(twolongs&),
  235.   Fix48_overflow_saturate(twolongs&),
  236.   Fix48_overflow_warning_saturate(twolongs&),
  237.   Fix48_warning(twolongs&),
  238.   Fix48_abort(twolongs&);
  239.  
  240.  
  241. inline Fix24::~Fix24() {}
  242.  
  243. inline Fix24::Fix24(long i)        
  244. { 
  245.   m = i; 
  246. }
  247.  
  248. inline Fix24::Fix24(int i)        
  249. { 
  250.   m = i; 
  251. }
  252.  
  253. inline Fix24::operator double() 
  254. { 
  255.   return  Fix24_div * m; 
  256. }
  257.  
  258. inline Fix24::Fix24()                 
  259. { 
  260.   m = 0; 
  261. }
  262.  
  263. inline Fix24::Fix24(Fix24&  f)        
  264. { 
  265.   m = f.m; 
  266. }
  267.  
  268. inline Fix24::Fix24(double d)        
  269. {
  270.   m = assign(d);
  271. }
  272.  
  273. inline Fix24::Fix24(Fix48& f)        
  274. { 
  275.   m = f.m.u;
  276. }
  277.  
  278. inline Fix24&  Fix24::operator=(Fix24&  f)    
  279. { 
  280.   m = f.m; 
  281.   return *this; 
  282. }
  283.  
  284. inline Fix24&  Fix24::operator=(double d) 
  285. { 
  286.   m = assign(d); 
  287.   return *this; 
  288. }
  289.  
  290. inline Fix24&  Fix24::operator=(Fix48& f)
  291. { 
  292.   m = f.m.u;
  293.   return *this; 
  294. }
  295.  
  296. inline long& mantissa(Fix24&  f)    
  297. { 
  298.   return f.m; 
  299. }
  300.  
  301. inline double value(Fix24&  f)        
  302. { 
  303.   return double(f); 
  304. }
  305.  
  306. inline Fix24 Fix24::operator+()         
  307. { 
  308.   return m; 
  309. }
  310.  
  311. inline Fix24 Fix24::operator-()         
  312. { 
  313.   return -m; 
  314. }
  315.  
  316. inline Fix24 operator+(Fix24&  f, Fix24&  g) 
  317. {
  318.   long sum = f.m + g.m;
  319.   if ( (f.m ^ sum) & (g.m ^ sum) & Fix24_msb )
  320.     f.overflow(sum);
  321.   return sum;
  322. }
  323.  
  324. inline Fix24 operator-(Fix24&  f, Fix24&  g) 
  325. {
  326.   long sum = f.m - g.m;
  327.   if ( (f.m ^ sum) & (-g.m ^ sum) & Fix24_msb )
  328.     f.overflow(sum);
  329.   return sum;
  330. }
  331.  
  332. inline Fix24 operator*(Fix24& a, int b)     
  333. { 
  334.   return a.m * b; 
  335. }
  336.  
  337. inline Fix24 operator*(int b, Fix24& a)     
  338. { 
  339.   return a * b; 
  340. }
  341.  
  342. inline Fix24 operator<<(Fix24& a, int b)     
  343. { 
  344.   return a.m << b; 
  345. }
  346.  
  347. inline Fix24 operator>>(Fix24& a, int b)     
  348. { 
  349.   return (a.m >> b) & 0xffffff00L; 
  350. }
  351.  
  352. inline  Fix24&  Fix24:: operator+=(Fix24&  f)
  353. { 
  354.   return *this = *this + f; 
  355. }
  356.  
  357. inline Fix24&  Fix24:: operator-=(Fix24&  f)     
  358. { 
  359.   return *this = *this - f; 
  360. }
  361.  
  362. inline Fix24& Fix24::operator*=(Fix24& f)     
  363. { 
  364.   return *this = *this * f; 
  365. }
  366.  
  367. inline Fix24&  Fix24:: operator/=(Fix24&  f)     
  368. { 
  369.   return *this = *this / f; 
  370. }
  371.  
  372. inline Fix24&  Fix24:: operator<<=(int b)    
  373. { 
  374.   return *this = *this << b;
  375. }
  376.  
  377. inline Fix24&  Fix24:: operator>>=(int b)    
  378. { 
  379.   return *this = *this >> b;
  380. }
  381.  
  382. inline Fix24& Fix24::operator*=(int b)
  383. { 
  384.   return *this = *this * b; 
  385. }
  386.  
  387. inline int operator==(Fix24&  f, Fix24&  g)    
  388. { 
  389.   return f.m == g.m;
  390. }
  391.  
  392. inline int operator!=(Fix24&  f, Fix24&  g)    
  393. { 
  394.   return f.m != g.m;
  395. }
  396.  
  397. inline int operator>=(Fix24&  f, Fix24&  g)    
  398. { 
  399.   return f.m >= g.m;
  400. }
  401.  
  402. inline int operator<=(Fix24&  f, Fix24&  g)    
  403. { 
  404.   return f.m <= g.m;
  405. }
  406.  
  407. inline int operator>(Fix24&  f, Fix24&  g)    
  408. { 
  409.   return f.m > g.m;
  410. }
  411.  
  412. inline int operator<(Fix24&  f, Fix24&  g)    
  413. { 
  414.   return f.m < g.m;
  415. }
  416.  
  417. inline istream&  operator>>(istream& s, Fix24&  f)
  418. { 
  419.   double d;
  420.   s >> d; 
  421.   f = d; 
  422.   return s; 
  423. }
  424.  
  425. inline ostream&  operator<<(ostream& s, Fix24&  f)
  426. { 
  427.   return s << double(f);
  428. }
  429.  
  430. inline Fix48::~Fix48() {}
  431.  
  432. inline Fix48::Fix48(twolongs i)        
  433. { 
  434.   m = i;
  435. }
  436.  
  437. inline Fix48:: operator double()        
  438. { 
  439. /*
  440.  * Note: can't simply do Fix48_div_u * m.u + Fix48_div_l * m.l, because
  441.  * m.u is signed and m.l is unsigned.
  442.  */
  443.   return (m.u >= 0)? Fix48_div_u * m.u + Fix48_div_l * m.l :
  444.       (Fix48_div_u * ((unsigned long)(m.u & 0xffffff00)) 
  445.       + Fix48_div_l * m.l) - 2;
  446. }
  447.  
  448. inline Fix48::Fix48()                
  449. { 
  450.   m.u = 0;
  451.   m.l = 0;
  452. }
  453.  
  454. inline Fix48::Fix48(Fix48& f)        
  455. { 
  456.   m = f.m;
  457. }
  458.  
  459. inline Fix48::Fix48(Fix24&  f)    
  460. { 
  461.   m.u = f.m;
  462.   m.l = 0;
  463. }
  464.  
  465. inline Fix48::Fix48(double d)        
  466. { 
  467.   m = assign(d);
  468. }
  469.  
  470. inline Fix48& Fix48::operator=(Fix48& f)    
  471. { 
  472.   m = f.m;
  473.   return *this; 
  474. }
  475.  
  476. inline Fix48& Fix48::operator=(Fix24&  f)    
  477. { 
  478.   m.u = f.m;
  479.   m.l = 0;
  480.   return *this;
  481. }
  482.  
  483. inline Fix48& Fix48::operator=(double d)    
  484. { 
  485.   m = assign(d);
  486.   return *this; 
  487. }
  488.  
  489. inline twolongs& mantissa(Fix48& f)    
  490. { 
  491.   return f.m;
  492. }
  493.  
  494. inline double value(Fix48& f)        
  495. { 
  496.   return double(f);
  497. }
  498.  
  499. inline Fix48 Fix48::operator+()         
  500. { 
  501.   return m;
  502. }
  503.  
  504. inline Fix48 Fix48::operator-()         
  505. { 
  506.   twolongs n;
  507.   n.l = -m.l;
  508.   n.u = ~m.u + ((n.l ^ m.l) & Fix24_msb ? 0 : Fix24_lsb);
  509.   return Fix48(n);
  510. }
  511.  
  512. inline Fix48 operator*(int b, Fix48& a)     
  513. { 
  514.   return a * b; 
  515. }
  516.  
  517. inline Fix48& Fix48::operator+=(Fix48& f)     
  518. { 
  519.   return *this = *this + f;
  520. }
  521.  
  522. inline Fix48& Fix48::operator-=(Fix48& f)     
  523. { 
  524.   return *this = *this - f;
  525. }
  526.  
  527. inline Fix48& Fix48::operator*=(int b)    
  528. { 
  529.   return *this = *this * b;
  530. }
  531.  
  532. inline Fix48& Fix48::operator<<=(int b)    
  533. { 
  534.   return *this = *this << b;
  535. }
  536.  
  537. inline Fix48& Fix48::operator>>=(int b)    
  538. { 
  539.   return *this = *this >> b;
  540. }
  541.  
  542. inline int operator==(Fix48& f, Fix48& g)    
  543. { 
  544.   return f.m.u == g.m.u && f.m.l == g.m.l;
  545. }
  546.  
  547. inline int operator!=(Fix48& f, Fix48& g)    
  548. { 
  549.   return f.m.u != g.m.u || f.m.l != g.m.l;
  550. }
  551.  
  552. inline int operator>=(Fix48& f, Fix48& g)    
  553. { 
  554.   return f.m.u >= g.m.u || (f.m.u == g.m.u && f.m.l >= g.m.l);
  555. }
  556.  
  557. inline int operator<=(Fix48& f, Fix48& g)    
  558. { 
  559.   return f.m.u <= g.m.u || (f.m.u == g.m.u && f.m.l <= g.m.l);
  560. }
  561.  
  562. inline int operator>(Fix48& f, Fix48& g)    
  563. { 
  564.   return f.m.u > g.m.u || (f.m.u == g.m.u && f.m.l > g.m.l);
  565. }
  566.  
  567. inline int operator<(Fix48& f, Fix48& g)    
  568. { 
  569.   return f.m.u < g.m.u || (f.m.u == g.m.u && f.m.l < g.m.l);
  570. }
  571.  
  572. inline istream& operator>>(istream& s, Fix48& f)
  573. { 
  574.   double d;
  575.   s >> d; 
  576.   f = d; 
  577.   return s; 
  578. }
  579.  
  580. inline ostream& operator<<(ostream& s, Fix48& f)
  581. { 
  582.   return s << double(f);
  583. }
  584.  
  585. #endif
  586.